package com.ruoyi.system.service.impl;

import com.ruoyi.common.snmp.ip.Ping;
import com.ruoyi.system.domain.SnmpPing;
import com.ruoyi.system.domain.SnmpSystem;
import com.ruoyi.system.mapper.SnmpPingMapper;
import com.ruoyi.system.mapper.SnmpSystemMapper;
import com.ruoyi.system.service.ISnmpPingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

/**
 * 【请填写功能名称】Service业务层处理
 *
 * @author ruoyi
 * @date 2025-02-05
 */
@Service
public class SnmpPingServiceImpl implements ISnmpPingService
{
    @Autowired
    private SnmpPingMapper snmpPingMapper;
    @Autowired
    private SnmpSystemMapper snmpSystemMapper;

    /**
     * 查询【请填写功能名称】
     *
     * @param ip 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public SnmpPing selectSnmpPingByIp(String ip)
    {
        return snmpPingMapper.selectSnmpPingByIp(ip);
    }

    /**
     * 查询【请填写功能名称】列表
     *
     * @param snmpPing 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<SnmpPing> selectSnmpPingList(SnmpPing snmpPing)
    {
        return snmpPingMapper.selectSnmpPingList(snmpPing);
    }

    /**
     * 新增【请填写功能名称】
     *
     * @param snmpPing 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int insertSnmpPing(SnmpPing snmpPing) throws Exception {
        String ipaddress =snmpPing.getIp();
        //// 获取成功的 IP 列表
        List<String> ip = Ping.GetPingSuccessByThread(ipaddress, 24);

        // 创建一个固定大小的线程池
        int THREAD_POOL_SIZE = 10; // 根据系统资源调整线程池大小
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
        // 为每个IP创建一个Callable任务
        List<Future<Boolean>> futures = ip.stream()
                .map(itme -> executorService.submit(() -> SnmpPing(itme)))
                .collect(Collectors.toList());

        int returnNum=0;
        for (int i = 0; i < futures.size(); i++) {
            try {
                Boolean isOnline = futures.get(i).get();
                if(isOnline)
                {
                    returnNum=returnNum+1;
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

        // 关闭线程池
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(120, TimeUnit.SECONDS)) {
                executorService.shutdownNow(); // 强制关闭线程池
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow(); // 强制关闭线程池
            e.printStackTrace();
        }
        return  returnNum;
    }
    @Override
    public int insertOneSnmpPing(SnmpPing snmpPing) throws Exception {
        if(SnmpPing(snmpPing.getIp())) {
            return 1;
        }else {
            return 0;
        }
    }

    public boolean SnmpPing(String s) throws Exception {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SnmpPing pingSuccess = new SnmpPing();
        pingSuccess.setIp(s);
        pingSuccess.setSegment(s.substring(0, s.lastIndexOf(".")) + ".0");
        //判断是否有snmp协议
        pingSuccess.setIsSnmp(0);
        if (Ping.GetSnmpSuccess(s)) {
            pingSuccess.setIsSnmp(1);
            SnmpSystem entity = snmpSystemMapper.getBaseInfo(s);
            if (entity != null && entity.getIp() != null && entity.getIp().length() > 0) {
            } else {
                SnmpSystem systemInfo = new SnmpSystem();
                systemInfo.setIp(s);
                systemInfo.setSysDecsr("SNMP未查询");
                systemInfo.setSysObjectID("SNMP未查询");
                systemInfo.setSysUpTime("SNMP未查询");
                systemInfo.setSysContact("SNMP未查询");
                systemInfo.setSysName("SNMP未查询");
                systemInfo.setSysLocation("SNMP未查询");
                systemInfo.setSysService("SNMP未查询");
                systemInfo.setTypeName("未知设备");
                systemInfo.setTime(df.format(new Date()));
                snmpSystemMapper.insertSnmpSystem(systemInfo);
            }
        }
        pingSuccess.setNetmask("25");
        pingSuccess.setTime(df.format(new Date()));
        //查询ip是否已经存在
        SnmpPing pingselect = new SnmpPing();
        pingselect.setIp(s);
        List<SnmpPing> selectArry = snmpPingMapper.selectSnmpPingList(pingselect);
        int returnNum = 0;
        if (selectArry.size() > 0) {
            //已有ping数据
            returnNum = snmpPingMapper.updateSnmpPing(pingSuccess);
        } else {
            returnNum = snmpPingMapper.insertSnmpPing(pingSuccess);
        }
        if(returnNum>0)
        {
            return true;
        }
        return false;
    }

    /**
     * 修改【请填写功能名称】
     *
     * @param snmpPing 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int updateSnmpPing(SnmpPing snmpPing)
    {
        return snmpPingMapper.updateSnmpPing(snmpPing);
    }

    /**
     * 批量删除【请填写功能名称】
     *
     * @param ips 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteSnmpPingByIps(String[] ips)
    {
        return snmpPingMapper.deleteSnmpPingByIps(ips);
    }

    /**
     * 删除【请填写功能名称】信息
     *
     * @param ip 【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteSnmpPingByIp(String ip)
    {
        return snmpPingMapper.deleteSnmpPingByIp(ip);
    }
}
